package structure.bst.tree;

import utility.printer.BinaryTreeInfo;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 项目名称: vital
 * 包 名 称: com.bst.tree
 * 类 名 称: BinaryTree
 * 类 描 述: TODO
 * 创建时间: 2020/6/4 1:12 下午
 * 创 建 人: Justice
 */
@SuppressWarnings("unchecked")
public class BinaryTree<E> implements BinaryTreeInfo {
    // 元素个数
    protected int size;
    // 根结点
    protected Node<E> root;

    protected static class Node<E> {
        // 数据域
        E element;
        // 左子树
        Node<E> left;
        // 右子树
        Node<E> right;
        // 父结点
        Node<E> parent;

        public Node(E element, Node<E> parent) {
            this.element = element;
            this.parent = parent;
        }

        // 判断是否为叶子结点
        public boolean isLeaf() {
            return left == null && right == null;
        }

        // 判断是否有两个孩子
        public boolean hasTwoChildren() {
            return left != null && right != null;
        }
    }

    // 获取结点个数
    public int size() {
        return size;
    }

    // 判断是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    // 清空二叉树
    public void clear() {
        root = null;
        size = 0;
    }

    // 控制遍历个数
    public static abstract class Visitor<E> {
        boolean stop;

        // 如果返回true，就代表停止遍历
        protected abstract boolean visit(E element);
    }

    // 先序遍历
    public void preOrder(Visitor<E> visitor) {
        if (visitor == null) return;
        preOrder(root, visitor);
    }

    private void preOrder(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor.stop) return;
        visitor.stop = visitor.visit(node.element);
        System.out.println(node.element);
        preOrder(node.left, visitor);
        preOrder(node.right, visitor);
    }

    // 中序遍历
    public void inOrder(Visitor<E> visitor) {
        if (visitor == null) return;
        inOrder(root, visitor);
    }

    private void inOrder(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor.stop) return;
        inOrder(node.left, visitor);
        if (visitor.stop) return;
        visitor.stop = visitor.visit(node.element);
        System.out.println(node.element);
        inOrder(node.right, visitor);
    }

    // 后序遍历
    public void postOrder(Visitor<E> visitor) {
        if (visitor == null) return;
        postOrder(root, visitor);
    }

    private void postOrder(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor.stop) return;
        postOrder(node.left, visitor);
        postOrder(node.right, visitor);
        if (visitor.stop) return;
        visitor.stop = visitor.visit(node.element);
        System.out.println(node.element);
    }

    // 层次遍历
    public void levelOrder(Visitor<E> visitor) {
        if (root == null || visitor == null) return;
        Queue<Node<E>> queue = new LinkedList<Node<E>>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();
            System.out.println(node.element);
            if (visitor.visit(node.element)) return;
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }

    // 判断是否为完全二叉树
    public boolean isComplete() {
        if (root == null) return false;
        Queue<Node<E>> queue = new LinkedList<Node<E>>();
        queue.offer(root);
        boolean leaf = false;
        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();
            if (leaf && !node.isLeaf()) return false;
            if (node.left != null) {
                // 左非空，加入队列
                queue.offer(node.left);
            } else if (node.right != null) {
                // 左空，右非空，错
                return false;
            }
            if (node.right != null) {
                // 右非空，直接加入队列
                queue.offer(node.right);
            } else {
                // 后面遍历的节点都必须是叶子节点
                leaf = true;
            }
        }
        return true;
    }

    // 二叉树高度 迭代
    public int height() {
        if (root == null) return 0;
        // 树的高度
        int height = 0;
        // 存储着每一层的元素数量
        int levelSize = 1;
        Queue<Node<E>> queue = new LinkedList<Node<E>>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();
            levelSize--;
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
            if (levelSize == 0) { // 意味着即将要访问下一层
                levelSize = queue.size();
                height++;
            }
        }
        return height;
    }

    // 二叉树求高度 递归
    public int height2() {
        return height(root);
    }

    private int height(Node<E> node) {
        if (node == null) return 0;
        return 1 + Math.max(height(node.left), height(node.right));
    }

    // 前驱结点
    protected Node<E> predecessor(Node<E> node) {
        if (node == null) return null;
        // 前驱节点在左子树当中（left.right.right.right....）
        Node<E> p = node.left;
        if (p != null) {
            while (p.right != null) {
                p = p.right;
            }
            return p;
        }
        // 从父节点、祖父节点中寻找前驱节点
        while (node.parent != null && node == node.parent.left) {
            node = node.parent;
        }
        // node.parent == null
        // node == node.parent.right
        return node.parent;
    }

    // 后继结点
    protected Node<E> successor(Node<E> node) {
        if (node == null) return null;
        // 前驱节点在左子树当中（right.left.left.left....）
        Node<E> p = node.right;
        if (p != null) {
            while (p.left != null) {
                p = p.left;
            }
            return p;
        }
        // 从父节点、祖父节点中寻找前驱节点
        while (node.parent != null && node == node.parent.right) {
            node = node.parent;
        }
        return node.parent;
    }


    public Object root() {
        return root;
    }


    public Object left(Object node) {
        return ((Node<E>) node).left;
    }


    public Object right(Object node) {
        return ((Node<E>) node).right;
    }


    public Object string(Object node) {
        Node<E> myNode = (Node<E>) node;
        String parentString = "null";
        if (myNode.parent != null) {
            parentString = myNode.parent.element.toString();
        }
        return myNode.element + "_p(" + parentString + ")";
    }
}
